package org.asiainfo.common.tenant.utils;

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.ObjectUtil;
import com.mybatisflex.core.tenant.TenantManager;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.asiainfo.common.core.constant.GlobalConstants;
import org.asiainfo.common.core.utils.SpringUtils;
import org.asiainfo.common.redis.utils.RedisUtils;
import org.asiainfo.common.satoken.utils.LoginHelper;

import java.time.Duration;
import java.util.function.Supplier;

/**
 * 租户工具类
 *
 * @author dotor-ww
 */
@Slf4j
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class TenantHelper {

    private static final String DYNAMIC_TENANT_KEY = GlobalConstants.GLOBAL_REDIS_KEY + "dynamicTenant";

    private static final ThreadLocal<Long> TEMP_DYNAMIC_TENANT = new ThreadLocal<>();

    /**
     * 租户功能是否启用
     */
    public static boolean isEnable() {
        return Convert.toBool(SpringUtils.getProperty("tenant.enabled"), false);
    }

    /**
     * 开启忽略租户(开启后需手动调用 {@link #disableIgnore()} 关闭)
     */
    public static void enableIgnore() {
        TenantManager.ignoreTenantCondition();
    }

    /**
     * 关闭忽略租户
     */
    public static void disableIgnore() {
        TenantManager.restoreTenantCondition();
    }

    /**
     * 在忽略租户中执行
     *
     * @param handle 处理执行方法
     */
    public static void ignore(Runnable handle) {
        enableIgnore();
        try {
            handle.run();
        } finally {
            disableIgnore();
        }
    }

    /**
     * 在忽略租户中执行
     *
     * @param handle 处理执行方法
     */
    public static <T> T ignore(Supplier<T> handle) {
        enableIgnore();
        try {
            return handle.get();
        } finally {
            disableIgnore();
        }
    }

    /**
     * 设置动态租户(当前线程有效)
     *
     * @param tenantId 租户ID
     * @param global   是否全局生效
     */
    public static void setDynamic(Long tenantId, boolean global) {
        if (!isEnable()) {
            return;
        }
        if (!isLogin() || !global) {
            TEMP_DYNAMIC_TENANT.set(tenantId);
            return;
        }
        String cacheKey = String.join(":", DYNAMIC_TENANT_KEY, StpUtil.getTokenValue());
        RedisUtils.setCacheObject(cacheKey, tenantId, Duration.ofSeconds(604800));
    }

    /**
     * 获取动态租户
     *
     * @return 租户ID
     */
    public static Long getDynamic() {
        if (!isEnable()) {
            return null;
        }
        if (!isLogin()) {
            return TEMP_DYNAMIC_TENANT.get();
        }
        String cacheKey = String.join(":", DYNAMIC_TENANT_KEY, StpUtil.getTokenValue());
        // 线程内有值 优先返回
        Long tenantId = TEMP_DYNAMIC_TENANT.get();
        if (ObjectUtil.isNotNull(tenantId)) {
            return tenantId;
        }
        tenantId = RedisUtils.getCacheObject(cacheKey);
        return tenantId;
    }

    /**
     * 清除动态租户
     */
    public static void clearDynamic() {
        if (!isEnable()) {
            return;
        }
        if (!isLogin()) {
            TEMP_DYNAMIC_TENANT.remove();
            return;
        }
        String cacheKey = String.join(":", DYNAMIC_TENANT_KEY, StpUtil.getTokenValue());
        RedisUtils.deleteObject(cacheKey);
    }

    /**
     * 动态执行
     *
     * @param tenantId 租户ID
     * @param runnable 处理执行
     */
    public static void dynamic(Long tenantId, Runnable runnable) {
        setDynamic(tenantId);
        try {
            runnable.run();
        } finally {
            clearDynamic();
        }
    }

    /**
     * 动态执行
     *
     * @param tenantId 租户ID
     * @param supplier 处理执行
     */
    public static <T> T dynamic(Long tenantId, Supplier<T> supplier) {
        setDynamic(tenantId);
        try {
            return supplier.get();
        } finally {
            clearDynamic();
        }
    }

    public static void setDynamic(Long tenantId) {
        setDynamic(tenantId, false);
    }

    /**
     * 获取当前租户id(动态租户优先)
     */
    public static Long getTenantId() {
        if (!isEnable()) {
            return null;
        }
        // 默认从缓存中先获取租户ID
        Long tenantId = TenantHelper.getDynamic();
        // 若缓存中没有值 则从登录信息中获取租户ID
        if (ObjectUtil.isNull(tenantId)) {
            tenantId = LoginHelper.getTenantId();
        }
        return tenantId;
    }

    /**
     * 判断用户是否登录
     *
     * @return 登录状态
     */
    private static Boolean isLogin() {
        try {
            StpUtil.checkLogin();
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}
